package com.estore.service;

import com.estore.model.Product;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private final Map<String, Product> productData = new HashMap<>();

    /**
     * 构造函数，初始化一些商品数据
     */
    public ProductService() {
        initializeSampleData();
    }

    /**
     * 初始化示例商品数据
     */
    private void initializeSampleData() {
        // 清除现有数据
        productData.clear();

        // 添加示例商品
        addProduct(new Product("p001", "Java从入门到精通", 99.0, 100));
        addProduct(new Product("p002", "高性能MySQL", 128.5, 50));
        addProduct(new Product("p003", "颈椎康复指南", 45.0, 200));
        addProduct(new Product("p004", "生发秘籍", 88.0, 0)); // 库存为0的商品
        addProduct(new Product("p005", "Python编程实战", 79.9, 80));
        addProduct(new Product("p006", "数据结构与算法", 120.0, 30));
        addProduct(new Product("p007", "设计模式之美", 65.5, 150));
        addProduct(new Product("p008", "Spring Boot实战", 89.0, 60));
    }

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        // 从Map的值集合创建一个新的ArrayList并返回
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }

    /**
     * 根据商品名称搜索商品（模糊匹配）
     * @param name 商品名称关键词
     * @return 匹配的商品列表
     */
    public List<Product> searchProductsByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return getAllProducts();
        }

        String searchTerm = name.toLowerCase().trim();
        return productData.values().stream()
                .filter(product -> product.getName().toLowerCase().contains(searchTerm))
                .collect(Collectors.toList());
    }

    /**
     * 根据价格范围搜索商品
     * @param minPrice 最低价格（包含）
     * @param maxPrice 最高价格（包含）
     * @return 价格在指定范围内的商品列表
     */
    public List<Product> searchProductsByPriceRange(double minPrice, double maxPrice) {
        return productData.values().stream()
                .filter(product -> product.getPrice() >= minPrice && product.getPrice() <= maxPrice)
                .collect(Collectors.toList());
    }

    /**
     * 获取有库存的商品列表
     * @return 库存大于0的商品列表
     */
    public List<Product> getAvailableProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() > 0)
                .collect(Collectors.toList());
    }

    /**
     * 获取缺货商品列表
     * @return 库存为0的商品列表
     */
    public List<Product> getOutOfStockProducts() {
        return productData.values().stream()
                .filter(product -> product.getStock() == 0)
                .collect(Collectors.toList());
    }

    /**
     * 添加新商品
     * @param product 要添加的商品对象
     * @return 添加成功返回true，如果商品ID已存在返回false
     */
    public boolean addProduct(Product product) {
        if (product == null || product.getId() == null || product.getId().trim().isEmpty()) {
            return false;
        }

        if (productData.containsKey(product.getId())) {
            return false; // 商品ID已存在
        }

        productData.put(product.getId(), product);
        return true;
    }

    /**
     * 更新商品信息
     * @param product 要更新的商品对象
     * @return 更新成功返回true，如果商品不存在返回false
     */
    public boolean updateProduct(Product product) {
        if (product == null || product.getId() == null || !productData.containsKey(product.getId())) {
            return false;
        }

        productData.put(product.getId(), product);
        return true;
    }

    /**
     * 删除商品
     * @param productId 要删除的商品ID
     * @return 删除成功返回被删除的商品，如果商品不存在返回null
     */
    public Product deleteProduct(String productId) {
        return productData.remove(productId);
    }

    /**
     * 更新商品库存
     * @param productId 商品ID
     * @param newStock 新的库存数量
     * @return 更新成功返回true，如果商品不存在或库存为负数返回false
     */
    public boolean updateStock(String productId, int newStock) {
        Product product = findProductById(productId);
        if (product == null || newStock < 0) {
            return false;
        }

        product.setStock(newStock);
        return true;
    }

    /**
     * 减少商品库存（用于购买操作）
     * @param productId 商品ID
     * @param quantity 减少的数量
     * @return 操作成功返回true，如果商品不存在或库存不足返回false
     */
    public boolean decreaseStock(String productId, int quantity) {
        Product product = findProductById(productId);
        if (product == null || quantity <= 0 || product.getStock() < quantity) {
            return false;
        }

        product.setStock(product.getStock() - quantity);
        return true;
    }

    /**
     * 增加商品库存（用于补货操作）
     * @param productId 商品ID
     * @param quantity 增加的数量
     * @return 操作成功返回true，如果商品不存在或增加数量为负数返回false
     */
    public boolean increaseStock(String productId, int quantity) {
        Product product = findProductById(productId);
        if (product == null || quantity <= 0) {
            return false;
        }

        product.setStock(product.getStock() + quantity);
        return true;
    }

    /**
     * 获取商品总数
     * @return 商品总数
     */
    public int getTotalProductCount() {
        return productData.size();
    }

    /**
     * 获取有库存商品数量
     * @return 有库存商品数量
     */
    public int getAvailableProductCount() {
        return (int) productData.values().stream()
                .filter(product -> product.getStock() > 0)
                .count();
    }

    /**
     * 获取所有商品的总价值（价格 × 库存）
     * @return 总价值
     */
    public double getTotalInventoryValue() {
        return productData.values().stream()
                .mapToDouble(product -> product.getPrice() * product.getStock())
                .sum();
    }

    /**
     * 检查商品是否存在
     * @param productId 商品ID
     * @return 存在返回true，否则返回false
     */
    public boolean productExists(String productId) {
        return productData.containsKey(productId);
    }

    /**
     * 检查商品是否有足够库存
     * @param productId 商品ID
     * @param requiredQuantity 所需数量
     * @return 库存足够返回true，否则返回false
     */
    public boolean hasEnoughStock(String productId, int requiredQuantity) {
        Product product = findProductById(productId);
        return product != null && product.getStock() >= requiredQuantity;
    }

    /**
     * 获取最贵的商品
     * @return 价格最高的商品，如果没有商品返回null
     */
    public Product getMostExpensiveProduct() {
        return productData.values().stream()
                .max(Comparator.comparingDouble(Product::getPrice))
                .orElse(null);
    }

    /**
     * 获取最便宜的商品
     * @return 价格最低的商品，如果没有商品返回null
     */
    public Product getCheapestProduct() {
        return productData.values().stream()
                .min(Comparator.comparingDouble(Product::getPrice))
                .orElse(null);
    }

    /**
     * 获取库存最多的商品
     * @return 库存最多的商品，如果没有商品返回null
     */
    public Product getProductWithHighestStock() {
        return productData.values().stream()
                .max(Comparator.comparingInt(Product::getStock))
                .orElse(null);
    }

    /**
     * 清空所有商品数据
     */
    public void clearAllProducts() {
        productData.clear();
    }

    /**
     * 重新初始化示例数据
     */
    public void resetToSampleData() {
        initializeSampleData();
    }
}